{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/mnt/workspace/mdy/miniforge/envs/mdy/lib/python3.10/site-packages/_distutils_hack/__init__.py:53: UserWarning: Reliance on distutils from stdlib is deprecated. Users must rely on setuptools to provide the distutils module. Avoid importing distutils or import setuptools first, and avoid setting SETUPTOOLS_USE_DISTUTILS=stdlib. Register concerns at https://github.com/pypa/setuptools/issues/new?template=distutils-deprecation.yml\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import triton\n",
    "import triton.language as tl\n",
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 将up * silu(gate)进行优化，可以节约显存，不需要保存silu(gate)这个中间结果\n",
    "- 主要3个版本，v1和v2类似，v1是行操作，v2是元素操作，性能差不过。这两个版本针对gate和up是单独计算的，都是连续的，提速大概2倍\n",
    "- v3是up和gate是拼在一起的，不需要进行chunk，提速3-4倍"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 按行处理\n",
    "\n",
    "@triton.jit\n",
    "def _fused_silu_fwd(\n",
    "        UP, GATE, Y,\n",
    "        M, N,\n",
    "        stride_m, stride_n,  #\n",
    "        BLOCK_SIZE_N: tl.constexpr, #\n",
    "        num_stages: tl.constexpr,\n",
    "):\n",
    "\n",
    "    pid = tl.program_id(axis=0)\n",
    "    offset = pid * stride_m\n",
    "    UP += offset\n",
    "    GATE += offset\n",
    "    Y += offset\n",
    "    # cols = tl.arange(0, BLOCK_SIZE_N)\n",
    "    # mask = cols < N\n",
    "    # ptrs = offset + cols\n",
    "\n",
    "    # up = tl.load(UP+ptrs, mask=mask, other=0.)\n",
    "    # dtype = up.dtype\n",
    "    # up = up.to(tl.float32)\n",
    "    # gate = tl.load(GATE+ptrs, mask=mask, other=0.).to(tl.float32)\n",
    "    # act = gate * tl.sigmoid(gate)\n",
    "    # y = act * up\n",
    "    # tl.store(Y+ptrs, y.to(dtype), mask=mask)\n",
    "    cols = tl.arange(0, BLOCK_SIZE_N)\n",
    "    for start_n in tl.range(0, N, BLOCK_SIZE_N):\n",
    "        new_cols = cols + start_n\n",
    "        mask = new_cols < N\n",
    "        up = tl.load(UP+new_cols, mask=mask, other=0.)\n",
    "        dtype = up.dtype\n",
    "        up = up.to(tl.float32)\n",
    "        gate = tl.load(GATE+new_cols, mask=mask, other=0.).to(tl.float32)\n",
    "        act = gate * tl.sigmoid(gate)\n",
    "        y = act * up\n",
    "        tl.store(Y+new_cols, y.to(dtype), mask=mask)\n",
    "\n",
    "@triton.jit\n",
    "def _fused_silu_bwd_dupgate(UP, GATE, \n",
    "                               DY, DUP, DGATE,\n",
    "                               stride_m, stride_n,\n",
    "                               N, BLOCK_N: tl.constexpr,\n",
    "                               num_stages: tl.constexpr):\n",
    "    pid = tl.program_id(0)\n",
    "    offset = pid * stride_m\n",
    "    UP += offset\n",
    "    GATE += offset\n",
    "    DUP += offset\n",
    "    DGATE += offset\n",
    "    DY += offset\n",
    "    # cols = tl.arange(0, BLOCK_N)\n",
    "    # ptrs = offset + cols\n",
    "    # mask = cols < N\n",
    "    \n",
    "    # dy = tl.load(DY+ptrs, mask=mask, other=0.)\n",
    "    # dtype = dy.dtype\n",
    "    # gate = tl.load(GATE+ptrs, mask=mask, other=0.).to(tl.float32)\n",
    "    # up = tl.load(UP+ptrs, mask=mask, other=0.).to(tl.float32)\n",
    "\n",
    "    # act = gate * tl.sigmoid(gate)\n",
    "    # dup = act * dy\n",
    "    # dact = up * dy\n",
    "    # gate_neg_exp = tl.exp(-gate)\n",
    "    # tmp = 1 + gate_neg_exp\n",
    "    # fenzi =  tmp + gate * gate_neg_exp\n",
    "    # fenmu = tmp * tmp\n",
    "    # dgate = (fenzi / fenmu) * dact\n",
    "    # tl.store(DUP+ptrs, dup.to(dtype), mask=mask)\n",
    "    # tl.store(DGATE+ptrs, dgate.to(dtype), mask=mask)\n",
    "    cols = tl.arange(0, BLOCK_N)\n",
    "    for start_n in range(0, N, BLOCK_N):\n",
    "        new_cols = cols + start_n\n",
    "        mask = new_cols < N\n",
    "        \n",
    "        dy = tl.load(DY+new_cols, mask=mask, other=0.)\n",
    "        dtype = dy.dtype\n",
    "        gate = tl.load(GATE+new_cols, mask=mask, other=0.).to(tl.float32)\n",
    "        up = tl.load(UP+new_cols, mask=mask, other=0.).to(tl.float32)\n",
    "        gate_sigmoid = tl.sigmoid(gate)\n",
    "        act = gate_sigmoid * gate\n",
    "        dup = act * dy\n",
    "        dact = up * dy\n",
    "        dgate = (gate_sigmoid + act * (1-gate_sigmoid)) * dact\n",
    "        tl.store(DUP+new_cols, dup.to(dtype), mask=mask)\n",
    "        tl.store(DGATE+new_cols, dgate.to(dtype), mask=mask)\n",
    "\n",
    "class _FusedSiLU(torch.autograd.Function):\n",
    "    @staticmethod\n",
    "    def forward(ctx, up, gate):\n",
    "        up = up.view(-1, up.shape[-1])\n",
    "        M, N = up.shape\n",
    "        y = torch.empty_like(gate)\n",
    "        BLOCK_SIZE_N = triton.next_power_of_2(N)\n",
    "        BLOCK_SIZE_N = min(4096, BLOCK_SIZE_N)\n",
    "        num_warps = 8\n",
    "        num_stages = 4\n",
    "        _fused_silu_fwd[(M,)](\n",
    "            up, gate, y, \n",
    "            M, N,  #\n",
    "            *up.stride(),  #\n",
    "            BLOCK_SIZE_N,\n",
    "            num_warps=num_warps, num_stages=num_stages, \n",
    "        )\n",
    "        ctx.infos = (M, N, BLOCK_SIZE_N, *up.stride())\n",
    "        ctx.save_for_backward(up, gate)\n",
    "        ctx.num_warps = num_warps\n",
    "        ctx.num_stages = num_stages\n",
    "        return y\n",
    "    \n",
    "    @staticmethod\n",
    "    def backward(ctx, dy):\n",
    "        # print(dy.stride())\n",
    "        M, N, BLOCK_SIZE_N, stride_m, stride_n = ctx.infos\n",
    "        # print(stride_m, stride_n)\n",
    "        up, gate = ctx.saved_tensors\n",
    "\n",
    "        dup = torch.empty_like(gate)\n",
    "        dgate = torch.empty_like(gate)\n",
    "        # BLOCK_SIZE_N = min(8192, BLOCK_SIZE_N)\n",
    "        _fused_silu_bwd_dupgate[(M,)](up, gate,\n",
    "                                   dy, dup, dgate,\n",
    "                                   stride_m, stride_n,\n",
    "                                   N, BLOCK_SIZE_N, \n",
    "                                   num_warps=ctx.num_warps, num_stages=ctx.num_stages)\n",
    "\n",
    "        return dup, dgate\n",
    "\n",
    "\n",
    "def up_gate_silu(up, gate):\n",
    "    return up * torch.nn.functional.silu(gate)\n",
    "\n",
    "fused_up_gate_silu = _FusedSiLU.apply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 与unsloth中的类似，逐元素处理\n",
    "\n",
    "@triton.jit\n",
    "def _fused_silu_fwd_unsloth(\n",
    "        UP, GATE, Y,\n",
    "        N, BLOCK_SIZE: tl.constexpr, #\n",
    "):\n",
    "\n",
    "    pid = tl.program_id(axis=0)\n",
    "    ptrs = pid * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)\n",
    "    mask = ptrs < N\n",
    "    up = tl.load(UP+ptrs, mask=mask, other=0.)\n",
    "    dtype = up.dtype\n",
    "    up = up.to(tl.float32)\n",
    "    gate = tl.load(GATE+ptrs, mask=mask, other=0.).to(tl.float32)\n",
    "    act = gate * tl.sigmoid(gate)\n",
    "    y = act * up\n",
    "    tl.store(Y+ptrs, y.to(dtype), mask=mask)\n",
    "\n",
    "@triton.jit\n",
    "def _fused_silu_bwd_dupgate_unsloth(UP, GATE, \n",
    "                               DY, DUP, DGATE,\n",
    "                               N, BLOCK_SIZE: tl.constexpr,):\n",
    "    pid = tl.program_id(axis=0)\n",
    "    ptrs = pid * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)\n",
    "    mask = ptrs < N\n",
    "        \n",
    "    dy = tl.load(DY+ptrs, mask=mask, other=0.)\n",
    "    dtype = dy.dtype\n",
    "    gate = tl.load(GATE+ptrs, mask=mask, other=0.).to(tl.float32)\n",
    "    up = tl.load(UP+ptrs, mask=mask, other=0.).to(tl.float32)\n",
    "    gate_sigmoid = tl.sigmoid(gate)\n",
    "    act = gate_sigmoid * gate\n",
    "    dup = act * dy\n",
    "    dact = up * dy\n",
    "    dgate = (gate_sigmoid + act * (1-gate_sigmoid)) * dact\n",
    "    tl.store(DUP+ptrs, dup.to(dtype), mask=mask)\n",
    "    tl.store(DGATE+ptrs, dgate.to(dtype), mask=mask)\n",
    "\n",
    "class _FusedSiLU_Unsloth(torch.autograd.Function):\n",
    "    @staticmethod\n",
    "    def forward(ctx, up, gate):\n",
    "        y = torch.empty_like(gate)\n",
    "        BLOCK_SIZE = 2048\n",
    "        N = up.nelement()\n",
    "        # print(N)\n",
    "        num_warps = 8\n",
    "        num_stages = 4\n",
    "        _fused_silu_fwd_unsloth[(triton.cdiv(N, BLOCK_SIZE),)](\n",
    "            up, gate, y, \n",
    "            N, BLOCK_SIZE,\n",
    "            num_warps=num_warps, num_stages=num_stages, \n",
    "        )\n",
    "        ctx.BLOCK_SIZE = BLOCK_SIZE\n",
    "        ctx.N = N\n",
    "        ctx.save_for_backward(up, gate)\n",
    "        ctx.num_warps = num_warps\n",
    "        ctx.num_stages = num_stages\n",
    "        return y\n",
    "    \n",
    "    @staticmethod\n",
    "    def backward(ctx, dy):\n",
    "        up, gate = ctx.saved_tensors\n",
    "        dup = torch.empty_like(gate)\n",
    "        dgate = torch.empty_like(gate)\n",
    "        _fused_silu_bwd_dupgate_unsloth[(triton.cdiv(ctx.N, ctx.BLOCK_SIZE),)](up, gate,\n",
    "                                   dy, dup, dgate,\n",
    "                                   ctx.N, ctx.BLOCK_SIZE, \n",
    "                                   num_warps=ctx.num_warps, num_stages=ctx.num_stages)\n",
    "\n",
    "        return dup, dgate\n",
    "\n",
    "\n",
    "def up_gate_silu(up, gate):\n",
    "    return up * torch.nn.functional.silu(gate)\n",
    "\n",
    "fused_up_gate_silu_unsloth = _FusedSiLU_Unsloth.apply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 精度测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim = 18944\n",
    "bs = 2\n",
    "seq_len = 2048\n",
    "dtype = torch.bfloat16\n",
    "up1 = torch.randn(bs, 2048, dim).cuda().to(dtype)\n",
    "gate1 = torch.randn(bs, 2048, dim).cuda().to(dtype)\n",
    "up1.requires_grad_(True)\n",
    "gate1.requires_grad_(True)\n",
    "up2 = deepcopy(up1)\n",
    "gate2 = deepcopy(gate1)\n",
    "dy = torch.ones_like(up1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "if up1.grad is not None:\n",
    "    up1.grad.zero_()\n",
    "    up2.grad.zero_()\n",
    "    gate1.grad.zero_()\n",
    "    gate2.grad.zero_()\n",
    "\n",
    "y1 = up_gate_silu(up1, gate1)\n",
    "y1.backward(dy)\n",
    "\n",
    "y2 = fused_up_gate_silu(up2, gate2)\n",
    "y2.backward(dy)\n",
    "\n",
    "atol = 1e-2\n",
    "print(torch.allclose(y1, y2, atol=atol))\n",
    "print(torch.allclose(up1.grad, up2.grad, atol=atol))\n",
    "print(torch.allclose(gate1.grad, gate2.grad, atol=atol))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(38797312, 18944, 1)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gate2.grad.stride()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward:\n",
      "    seq_len  Triton-FusedUpGateSiLU  Torch-UpGateSiLU     unsloth\n",
      "0     128.0               51.311657         78.049086   45.650594\n",
      "1     256.0               86.935535        131.831691   78.786485\n",
      "2     384.0              116.132155        188.488439  111.367501\n",
      "3     512.0              148.994893        245.735839  142.786458\n",
      "4     640.0              180.455387        305.902451  175.458401\n",
      "5     768.0              212.863773        360.769629  208.563909\n",
      "6     896.0              245.325193        416.853368  240.290508\n",
      "7    1024.0              278.548121        474.220604  272.357494\n",
      "8    1152.0              310.949862        531.358242  304.737687\n",
      "9    1280.0              343.738943        588.632345  336.770594\n",
      "10   1408.0              375.725150        649.334967  369.974315\n",
      "11   1536.0              408.962697        704.853952  401.741087\n",
      "12   1664.0              440.709710        760.229766  434.225082\n",
      "13   1792.0              473.501891        817.427993  466.127306\n",
      "14   1920.0              506.195009        873.428106  497.762024\n",
      "15   2048.0              538.749635        930.401325  530.323982\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU', 'unsloth'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",'unsloth'\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 18944, 'bs': 4}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    up = torch.randn(bs, seq_len, dim, device=device, dtype=dtype)\n",
    "    gate = torch.randn_like(up)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: fused_up_gate_silu(up, gate))\n",
    "\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: up_gate_silu(up, gate))\n",
    "\n",
    "    if provider == 'unsloth':\n",
    "        ms = triton.testing.do_bench(lambda: fused_up_gate_silu_unsloth(up, gate))\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward:\n",
      "       dim  Triton-FusedUpGateSiLU  Torch-UpGateSiLU     unsloth\n",
      "0    512.0               79.367734        119.083442   72.031535\n",
      "1   1024.0              134.312525        218.792737  128.255740\n",
      "2   1536.0              185.179889        318.034142  181.858227\n",
      "3   2048.0              237.317801        412.599087  238.348678\n",
      "4   2560.0              297.579318        510.872424  293.006003\n",
      "5   3072.0              349.587739        609.743774  348.785818\n",
      "6   3584.0              405.867875        710.851848  405.184537\n",
      "7   4096.0              460.165232        807.905436  461.037219\n",
      "8   4608.0              519.782424        906.388879  516.030431\n",
      "9   5120.0              574.536681       1007.358909  573.424697\n",
      "10  5632.0              631.117165       1104.874849  628.713310\n",
      "11  6144.0              687.125325       1201.895833  683.913708\n",
      "12  6656.0              742.222309       1300.229073  740.971744\n",
      "13  7168.0              796.840966       1401.401281  796.809316\n",
      "14  7680.0              852.880120       1499.720335  852.284133\n",
      "15  8192.0              907.905996       1595.935345  908.729315\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['dim'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[512 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU', 'unsloth'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",'unsloth'\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'seq_len': 1024, 'bs': 32}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    up = torch.randn(bs, seq_len, dim, device=device, dtype=dtype)\n",
    "    gate = torch.randn_like(up)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: fused_up_gate_silu(up, gate))\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: up_gate_silu(up, gate))\n",
    "    if provider == 'unsloth':\n",
    "        ms = triton.testing.do_bench(lambda: fused_up_gate_silu_unsloth(up, gate))\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward:\n",
      "    seq_len  Triton-FusedUpGateSiLU  Torch-UpGateSiLU     unsloth\n",
      "0     128.0               76.059155        130.185530   69.415890\n",
      "1     256.0              130.643770        228.088483  124.388605\n",
      "2     384.0              187.084526        331.381053  179.063708\n",
      "3     512.0              242.970541        431.499779  234.784678\n",
      "4     640.0              299.690545        530.416012  282.459408\n",
      "5     768.0              348.639309        626.253068  336.179078\n",
      "6     896.0              403.322309        725.149393  390.221596\n",
      "7    1024.0              458.295286        823.390067  444.416404\n",
      "8    1152.0              514.123261        925.199449  499.248654\n",
      "9    1280.0              569.772422       1024.993181  552.040517\n",
      "10   1408.0              624.733448       1123.264074  606.398165\n",
      "11   1536.0              679.413378       1223.321795  660.690188\n",
      "12   1664.0              735.455990       1322.945476  714.344859\n",
      "13   1792.0              789.716482       1423.413634  768.273652\n",
      "14   1920.0              845.389009       1524.354577  823.319793\n",
      "15   2048.0              899.743974       1623.279572  875.903308\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU', 'unsloth'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",'unsloth'\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 18944, 'bs': 4}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    up = torch.randn(bs, seq_len, dim, device=device, dtype=dtype)\n",
    "    up.requires_grad_(True)\n",
    "    gate = torch.randn_like(up)\n",
    "    gate.requires_grad_(True)\n",
    "    dy = torch.ones_like(up)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        y = fused_up_gate_silu(up, gate)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[up, gate])\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        y = up_gate_silu(up, gate)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[up, gate])\n",
    "    if provider == 'unsloth':\n",
    "        y = fused_up_gate_silu_unsloth(up, gate)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[up, gate])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu backward:\n",
      "       dim  Triton-FusedUpGateSiLU  Torch-UpGateSiLU      unsloth\n",
      "0    512.0              114.764154        201.825589   110.137545\n",
      "1   1024.0              205.374107        377.244532   204.629853\n",
      "2   1536.0              300.625712        555.156171   300.936878\n",
      "3   2048.0              396.385819        729.960918   395.744443\n",
      "4   2560.0              493.156582        905.090213   493.123591\n",
      "5   3072.0              572.192013       1061.242580   572.603524\n",
      "6   3584.0              666.954637       1235.213161   666.498840\n",
      "7   4096.0              761.382878       1408.275723   759.769082\n",
      "8   4608.0              855.613947       1581.305623   853.585303\n",
      "9   5120.0              955.990851       1753.918052   946.404576\n",
      "10  5632.0             1046.332717       1927.388668  1039.892197\n",
      "11  6144.0             1144.660115       2101.396322  1133.220196\n",
      "12  6656.0             1241.818190       2271.324396  1225.693226\n",
      "13  7168.0             1343.145609       2443.384171  1320.627570\n",
      "14  7680.0             1433.796644       2614.660501  1415.080070\n",
      "15  8192.0             1566.127896       2841.203690  1548.044920\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['dim'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[512 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU', 'unsloth'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",'unsloth'\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu backward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'seq_len': 1024, 'bs': 32}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    up = torch.randn(bs, seq_len, dim, device=device, dtype=dtype)\n",
    "    up.requires_grad_(True)\n",
    "    gate = torch.randn_like(up)\n",
    "    gate.requires_grad_(True)\n",
    "    dy = torch.ones_like(up)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        y = fused_up_gate_silu(up, gate)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[up, gate])\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        y = up_gate_silu(up, gate)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[up, gate])\n",
    "    if provider == 'unsloth':\n",
    "        y = fused_up_gate_silu_unsloth(up, gate)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[up, gate])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# forward + backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "forward + backward:\n",
      "    seq_len  Triton-FusedUpGateSiLU  Torch-UpGateSiLU      unsloth\n",
      "0     128.0              116.312034        195.294008   107.865833\n",
      "1     256.0              206.050307        348.098874   191.070989\n",
      "2     384.0              289.880484        504.111528   277.046710\n",
      "3     512.0              377.909541        661.999464   362.893552\n",
      "4     640.0              465.009779        817.976534   449.810028\n",
      "5     768.0              553.451538        975.995600   536.166549\n",
      "6     896.0              641.072392       1133.300304   622.021377\n",
      "7    1024.0              729.009867       1289.518476   708.114564\n",
      "8    1152.0              816.298306       1447.942972   794.735491\n",
      "9    1280.0              904.446781       1604.239702   880.138159\n",
      "10   1408.0              991.450965       1762.030363   966.881931\n",
      "11   1536.0             1079.732418       1918.559909  1053.977847\n",
      "12   1664.0             1168.753028       2076.270103  1139.202237\n",
      "13   1792.0             1255.268574       2230.274200  1224.020243\n",
      "14   1920.0             1343.492031       2388.036489  1311.444640\n",
      "15   2048.0             1430.598021       2546.473503  1397.464275\n"
     ]
    }
   ],
   "source": [
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU', 'unsloth'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",'unsloth'\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-'), ('orange', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"forward + backward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 18944, 'bs': 4}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    up = torch.randn(bs, seq_len, dim, device=device, dtype=dtype)\n",
    "    up.requires_grad_(True)\n",
    "    gate = torch.randn_like(up)\n",
    "    gate.requires_grad_(True)\n",
    "    dy = torch.ones_like(up)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    def func(ops, gate, up, dy):\n",
    "        y = ops(up, gate)\n",
    "        y.backward(dy)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: func(fused_up_gate_silu, gate, up, dy), grad_to_none=[up, gate])\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: func(up_gate_silu, gate, up, dy), grad_to_none=[up, gate])\n",
    "    if provider == 'unsloth':\n",
    "        ms = triton.testing.do_bench(lambda: func(fused_up_gate_silu_unsloth, gate, up, dy), grad_to_none=[up, gate])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward + backward:\n",
      "       dim  Triton-FusedUpGateSiLU  Torch-UpGateSiLU\n",
      "0    512.0              187.339664        313.333631\n",
      "1   1024.0              329.815477        590.434074\n",
      "2   1536.0              476.323873        863.433540\n",
      "3   2048.0              634.431541       1141.050220\n",
      "4   2560.0              791.469097       1416.579008\n",
      "5   3072.0              913.540542       1663.715363\n",
      "6   3584.0             1064.322591       1934.445143\n",
      "7   4096.0             1213.841081       2206.982851\n",
      "8   4608.0             1408.272028       2477.096319\n",
      "9   5120.0             1544.722319       2750.977278\n",
      "10  5632.0             1686.546206       3023.798227\n",
      "11  6144.0             1830.435634       3295.796871\n",
      "12  6656.0             1981.032729       3565.246105\n",
      "13  7168.0             2127.761841       3834.771395\n",
      "14  7680.0             2277.846575       4107.024670\n",
      "15  8192.0             2420.019865       4379.351139\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['dim'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[512 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward + backward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'seq_len': 1024, 'bs': 32}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    up = torch.randn(bs, seq_len, dim, device=device, dtype=dtype)\n",
    "    up.requires_grad_(True)\n",
    "    gate = torch.randn_like(up)\n",
    "    gate.requires_grad_(True)\n",
    "    dy = torch.ones_like(up)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    def func(ops, gate, up, dy):\n",
    "        y = ops(up, gate)\n",
    "        y.backward(dy)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: func(fused_up_gate_silu, gate, up, dy), grad_to_none=[up, gate])\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        y = up_gate_silu(up, gate)\n",
    "        ms = triton.testing.do_bench(lambda: func(up_gate_silu, gate, up, dy), grad_to_none=[up, gate])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# v3\n",
    "- 提供第三种接口，比如有同学的代码是这样的，MLP的up和gate是一个矩阵，计算效率高，但是后续需要去切，切出来的up和gate都不是连续的\n",
    "- 如果用v1和v2的话，都需要将其转换为连续的，降低效率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLP(torch.nn.Module):\n",
    "    def __init__(self, hidden_size, up_hidden_size):\n",
    "        super().__init__()\n",
    "        self.fc = torch.nn.Linear(hidden_size, up_hidden_size*2)\n",
    "        self.down = torch.nn.Linear(up_hidden_size, hidden_size)\n",
    "        self.act_fn = torch.nn.SiLU()\n",
    "    \n",
    "    def forward(self, hidden_states):\n",
    "        out = self.fc(hidden_states)\n",
    "        up, gate = out.chunk(2, -1)\n",
    "        return self.down(self.act_fn(gate) * up)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 按行处理\n",
    "\n",
    "@triton.jit\n",
    "def _fused_silu_fwdv2(X, Y,\n",
    "                    N, \n",
    "                    stride_m, stride_n,  #\n",
    "                    BLOCK_SIZE_N: tl.constexpr, ORDER:tl.constexpr,\n",
    "                    ):\n",
    "\n",
    "    pid = tl.program_id(axis=0)\n",
    "    x_offset = pid * stride_m\n",
    "    y_offset = x_offset // 2\n",
    "    X += x_offset\n",
    "    Y += y_offset\n",
    "    if ORDER == 'up-gate':\n",
    "        up_offset = 0\n",
    "        gate_offset = N\n",
    "    else:\n",
    "        up_offset = N\n",
    "        gate_offset = 0\n",
    "\n",
    "    cols = tl.arange(0, BLOCK_SIZE_N)\n",
    "    for start_n in tl.range(0, N, BLOCK_SIZE_N):\n",
    "        new_cols = cols + start_n\n",
    "        mask = new_cols < N\n",
    "        up = tl.load(X+new_cols+up_offset, mask=mask, other=0.)\n",
    "        dtype = up.dtype\n",
    "        up = up.to(tl.float32)\n",
    "        gate = tl.load(X+new_cols+gate_offset, mask=mask, other=0.).to(tl.float32)\n",
    "        act = gate * tl.sigmoid(gate)\n",
    "        y = act * up\n",
    "        tl.store(Y+new_cols, y.to(dtype), mask=mask)\n",
    "\n",
    "@triton.jit\n",
    "def _fused_silu_bwd_dupgatev2(X, \n",
    "                            DY, DX,\n",
    "                            N,\n",
    "                            stride_m, stride_n,\n",
    "                            BLOCK_SIZE_N: tl.constexpr,ORDER:tl.constexpr\n",
    "                            ):\n",
    "    pid = tl.program_id(0)\n",
    "    x_offset = pid * stride_m\n",
    "    y_offset = x_offset // 2\n",
    "    X += x_offset\n",
    "    DX += x_offset\n",
    "    DY += y_offset\n",
    "    if ORDER == 'up-gate':\n",
    "        up_offset = 0\n",
    "        gate_offset = N\n",
    "    else:\n",
    "        up_offset = N\n",
    "        gate_offset = 0\n",
    "\n",
    "    cols = tl.arange(0, BLOCK_SIZE_N)\n",
    "    for start_n in range(0, N, BLOCK_SIZE_N):\n",
    "        new_cols = cols + start_n\n",
    "        mask = new_cols < N\n",
    "        \n",
    "        dy = tl.load(DY+new_cols, mask=mask, other=0.)\n",
    "        dtype = dy.dtype\n",
    "        gate = tl.load(X+new_cols+gate_offset, mask=mask, other=0.).to(tl.float32)\n",
    "        up = tl.load(X+new_cols+up_offset, mask=mask, other=0.).to(tl.float32)\n",
    "        gate_sigmoid = tl.sigmoid(gate)\n",
    "        act = gate_sigmoid * gate\n",
    "        dup = act * dy\n",
    "        dact = up * dy\n",
    "        dgate = (gate_sigmoid + act * (1-gate_sigmoid)) * dact\n",
    "        tl.store(DX+new_cols+up_offset, dup.to(dtype), mask=mask)\n",
    "        tl.store(DX+new_cols+gate_offset, dgate.to(dtype), mask=mask)\n",
    "\n",
    "class _FusedSiLUNoSplit(torch.autograd.Function):\n",
    "    @staticmethod\n",
    "    def forward(ctx, x, order='up-gate'):\n",
    "        assert order in ['up-gate', 'gate-up'],\"please indicate the order of tht out, up-gate or gate-up\"\n",
    "        input_shape = x.shape\n",
    "        x = x.view(-1, input_shape[-1])\n",
    "        # print(x.stride())\n",
    "        M, N2 = x.shape\n",
    "        N = N2 // 2\n",
    "        y = torch.empty(*input_shape[:-1], N, device=x.device, dtype=x.dtype)\n",
    "        BLOCK_SIZE_N = triton.next_power_of_2(N)\n",
    "        BLOCK_SIZE_N = min(4096, BLOCK_SIZE_N)\n",
    "        num_warps = 8\n",
    "        num_stages = 4\n",
    "        _fused_silu_fwdv2[(M,)](\n",
    "            x, y, \n",
    "            N,  #\n",
    "            *x.stride(),  #\n",
    "            BLOCK_SIZE_N, order,\n",
    "            num_warps=num_warps, num_stages=num_stages, \n",
    "        )\n",
    "        ctx.infos = (M, N, BLOCK_SIZE_N, *x.stride(), order)\n",
    "        ctx.input_shape = input_shape\n",
    "        ctx.save_for_backward(x)\n",
    "        ctx.num_warps = num_warps\n",
    "        ctx.num_stages = num_stages\n",
    "        return y\n",
    "    \n",
    "    @staticmethod\n",
    "    def backward(ctx, dy):\n",
    "        # print(dy.stride())\n",
    "        M, N, BLOCK_SIZE_N, stride_m, stride_n, order = ctx.infos\n",
    "        # print(stride_m, stride_n)\n",
    "        x, = ctx.saved_tensors\n",
    "\n",
    "        dx = torch.empty(ctx.input_shape, device=dy.device, dtype=dy.dtype)\n",
    "        # BLOCK_SIZE_N = min(8192, BLOCK_SIZE_N)\n",
    "        _fused_silu_bwd_dupgatev2[(M,)](x,\n",
    "                                   dy, dx,\n",
    "                                   N,\n",
    "                                   stride_m, stride_n,\n",
    "                                   BLOCK_SIZE_N, order,\n",
    "                                   num_warps=ctx.num_warps, num_stages=ctx.num_stages)\n",
    "\n",
    "        return dx, None\n",
    "\n",
    "\n",
    "fused_up_gate_silu_no_split = _FusedSiLUNoSplit.apply\n",
    "\n",
    "def up_gate_silu_split(x):\n",
    "    up,gate = x.chunk(2, -1)\n",
    "    return up * torch.nn.functional.silu(gate)\n",
    "\n",
    "# 直接替换即可\n",
    "class NEWMLP(torch.nn.Module):\n",
    "    def __init__(self, hidden_size, up_hidden_size):\n",
    "        super().__init__()\n",
    "        self.fc = torch.nn.Linear(hidden_size, up_hidden_size*2)\n",
    "        self.down = torch.nn.Linear(up_hidden_size, hidden_size)\n",
    "        self.act_fn = torch.nn.SiLU()\n",
    "    \n",
    "    def forward(self, hidden_states):\n",
    "        # 一行代码搞定\n",
    "        return self.down(fused_up_gate_silu_no_split(self.fc(hidden_states, 'up-gate')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim = 4096\n",
    "bs = 2\n",
    "seq_len = 2048\n",
    "dtype = torch.float32\n",
    "x1 = torch.randn(bs, seq_len, dim*2).cuda().to(dtype)\n",
    "x1.requires_grad_(True)\n",
    "x2 = deepcopy(x1)\n",
    "dy = torch.randn(bs, seq_len, dim).cuda().to(dtype)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "if x1.grad is not None:\n",
    "    x1.grad.zero_()\n",
    "    x2.grad.zero_()\n",
    "y1 = up_gate_silu_split(x1)\n",
    "y1.backward(dy)\n",
    "\n",
    "y2 = fused_up_gate_silu_no_split(x2)\n",
    "y2.backward(dy)\n",
    "\n",
    "atol = 1e-4\n",
    "print(torch.allclose(y1, y2, atol=atol))\n",
    "print(torch.allclose(x1.grad, x2.grad, atol=atol))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward:\n",
      "    seq_len  Triton-FusedUpGateSiLU  Torch-UpGateSiLU\n",
      "0     128.0               45.258358         93.969427\n",
      "1     256.0               77.407934        170.266777\n",
      "2     384.0              100.446731        244.193092\n",
      "3     512.0              129.450336        320.233464\n",
      "4     640.0              156.931922        395.861208\n",
      "5     768.0              184.692502        471.936554\n",
      "6     896.0              213.335186        547.326922\n",
      "7    1024.0              240.711048        622.955680\n",
      "8    1152.0              269.488126        699.433565\n",
      "9    1280.0              296.626508        775.483370\n",
      "10   1408.0              324.775696        851.466775\n",
      "11   1536.0              352.623731        927.389920\n",
      "12   1664.0              381.102473       1001.876354\n",
      "13   1792.0              409.366459       1079.037309\n",
      "14   1920.0              437.853992       1153.563023\n",
      "15   2048.0              465.019733       1229.423761\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 4096*4, 'bs': 4}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim*2).to(device).to(dtype)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: fused_up_gate_silu_no_split(x))\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: up_gate_silu_split(x))\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward:\n",
      "    seq_len  Triton-FusedUpGateSiLU  Torch-UpGateSiLU\n",
      "0     128.0               64.888321        200.152352\n",
      "1     256.0              114.678860        368.754596\n",
      "2     384.0              158.152059        539.566100\n",
      "3     512.0              205.306500        713.350654\n",
      "4     640.0              252.594531        884.784400\n",
      "5     768.0              300.159156       1059.723377\n",
      "6     896.0              347.270846       1235.915899\n",
      "7    1024.0              394.201785       1567.914724\n",
      "8    1152.0              442.121029       1763.851047\n",
      "9    1280.0              488.823384       1957.287431\n",
      "10   1408.0              536.248863       1937.655091\n",
      "11   1536.0              583.243191       2114.478111\n",
      "12   1664.0              630.665839       2542.034864\n",
      "13   1792.0              677.315950       2602.772236\n",
      "14   1920.0              724.667788       2936.245680\n",
      "15   2048.0              770.981073       3131.736994\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 4096*4, 'bs': 4}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim*2).to(device).to(dtype)\n",
    "    x.requires_grad_(True)\n",
    "    dy = torch.randn(bs, seq_len, dim).cuda().to(dtype)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        y = fused_up_gate_silu_no_split(x)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[x])\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        y = up_gate_silu_split(x)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[x])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## forward + backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward:\n",
      "    seq_len  Triton-FusedUpGateSiLU  Torch-UpGateSiLU\n",
      "0     128.0              101.407997        285.060495\n",
      "1     256.0              184.007511        528.984904\n",
      "2     384.0              250.331640        774.577439\n",
      "3     512.0              326.748133       1024.197817\n",
      "4     640.0              401.128024       1272.540689\n",
      "5     768.0              475.097507       1523.560524\n",
      "6     896.0              552.634180       1773.248553\n",
      "7    1024.0              626.848459       2287.426949\n",
      "8    1152.0              701.888025       2508.886576\n",
      "9    1280.0              777.593970       2525.539160\n",
      "10   1408.0              852.678120       3134.435654\n",
      "11   1536.0              927.383304       3029.113531\n",
      "12   1664.0             1002.980947       3700.879335\n",
      "13   1792.0             1075.845957       3985.519886\n",
      "14   1920.0             1150.754809       4253.269672\n",
      "15   2048.0             1225.723863       4558.155537\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['Triton-FusedUpGateSiLU', 'Torch-UpGateSiLU'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"Triton-FusedUpGateSiLU\",\n",
    "            \"Torch-UpGateSiLU\",\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 4096*4, 'bs': 4}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim*2).to(device).to(dtype)\n",
    "    x.requires_grad_(True)\n",
    "    dy = torch.randn(bs, seq_len, dim).cuda().to(dtype)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    def fwd_bwd(func, x, dy):\n",
    "        y = func(x)\n",
    "        y.backward(dy,retain_graph=True)\n",
    "\n",
    "    if provider == 'Triton-FusedUpGateSiLU':\n",
    "        y = fused_up_gate_silu_no_split(x)\n",
    "        ms = triton.testing.do_bench(lambda: fwd_bwd(fused_up_gate_silu_no_split, x, dy), grad_to_none=[x])\n",
    "    if provider == 'Torch-UpGateSiLU':\n",
    "        ms = triton.testing.do_bench(lambda: fwd_bwd(up_gate_silu_split, x, dy), grad_to_none=[x])\n",
    "\n",
    "    return ms * 1e3\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## v3 pk v1 \n",
    "- 可见连续的重要性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fusefunc(x, func):\n",
    "    up, gate = x.chunk(2, -1)\n",
    "    up = up.contiguous()\n",
    "    gate = gate.contiguous()\n",
    "    y = func(up, gate)\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward:\n",
      "    seq_len          v3           v1\n",
      "0     128.0   46.457443   113.501757\n",
      "1     256.0   78.114271   216.532037\n",
      "2     384.0  101.115033   307.746559\n",
      "3     512.0  129.971564   400.637805\n",
      "4     640.0  156.992942   494.214118\n",
      "5     768.0  184.730634   588.744342\n",
      "6     896.0  213.561416   682.988942\n",
      "7    1024.0  241.535276   776.359439\n",
      "8    1152.0  268.862486   872.438669\n",
      "9    1280.0  296.908796   964.990914\n",
      "10   1408.0  324.747026  1059.353828\n",
      "11   1536.0  352.708071  1153.572917\n",
      "12   1664.0  380.682707  1247.307181\n",
      "13   1792.0  409.288079  1342.447758\n",
      "14   1920.0  437.789828  1436.005473\n",
      "15   2048.0  464.848369  1531.654596\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['v3', 'v1'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"v3\",\n",
    "            \"v1\",\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 4096*4, 'bs': 4}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim*2).to(device).to(dtype)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    if provider == 'v3':\n",
    "        ms = triton.testing.do_bench(lambda: fused_up_gate_silu_no_split(x))\n",
    "    if provider == 'v1':\n",
    "        ms = triton.testing.do_bench(lambda: fusefunc(x, fused_up_gate_silu))\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- backward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bs: 32, seq_len: 1024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "up gate silu forward:\n",
      "    seq_len          v3           v1\n",
      "0     128.0   64.837016   130.690977\n",
      "1     256.0  114.581622   239.338592\n",
      "2     384.0  158.776909   349.045277\n",
      "3     512.0  205.735952   461.985946\n",
      "4     640.0  252.855480   573.950410\n",
      "5     768.0  300.716221   706.256330\n",
      "6     896.0  347.425520   849.096656\n",
      "7    1024.0  394.477606   914.990723\n",
      "8    1152.0  441.438824  1030.401587\n",
      "9    1280.0  488.563538  1208.309293\n",
      "10   1408.0  535.532176  1259.826303\n",
      "11   1536.0  582.916379  1374.470353\n",
      "12   1664.0  629.796267  1572.819948\n",
      "13   1792.0  677.138567  1697.862029\n",
      "14   1920.0  725.114584  1816.100478\n",
      "15   2048.0  770.393729  1940.711021\n"
     ]
    }
   ],
   "source": [
    "\n",
    "torch.cuda.empty_cache()\n",
    "@triton.testing.perf_report(\n",
    "    triton.testing.Benchmark(\n",
    "        x_names=['seq_len'],  # argument names to use as an x-axis for the plot\n",
    "        x_vals=[128 * i for i in range(1, 16+1, 1)],  # different possible values for `x_name`\n",
    "        line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "        line_vals=['v3', 'v1'],  # possible values for `line_arg``\n",
    "        line_names=[\n",
    "            \"v3\",\n",
    "            \"v1\",\n",
    "        ],  # label name for the lines\n",
    "        styles=[('blue', '-'), ('green', '-')],  # line styles\n",
    "        ylabel=\"ms\",  # label name for the y-axis\n",
    "        plot_name=\"up gate silu forward\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "        args={'dim': 4096*4, 'bs': 4}\n",
    "        # args={'bs': 2, 'num_head': 32, 'rope_head_dim': 32, \n",
    "        #       'nope_head_dim': 64, 'kv_lora_rank': 256},  # values for function arguments not in `x_names` and `y_name`\n",
    "    ))\n",
    "def benchmark(bs, seq_len, dim, provider):\n",
    "    device = torch.device('cuda')\n",
    "    dtype = torch.float16\n",
    "    x = torch.randn(bs, seq_len, dim*2).to(device).to(dtype)\n",
    "    x.requires_grad_(True)\n",
    "    dy = torch.randn(bs, seq_len, dim).to(device).to(dtype)\n",
    "    stream = torch.cuda.Stream()\n",
    "    torch.cuda.set_stream(stream)\n",
    "\n",
    "    if provider == 'v3':\n",
    "        y = fused_up_gate_silu_no_split(x)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[x])\n",
    "    if provider == 'v1':\n",
    "        y = fusefunc(x, fused_up_gate_silu)\n",
    "        ms = triton.testing.do_bench(lambda: y.backward(dy,retain_graph=True), grad_to_none=[x])\n",
    "\n",
    "    return ms * 1e3\n",
    "print(f'bs: {32}, seq_len: {1024}')\n",
    "benchmark.run(show_plots=True, print_data=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
